package com.austin.smp.common.util;

import org.springframework.util.StringUtils;

import java.beans.PropertyEditorSupport;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 类描述：时间操作定义类
 *
 * @Version 1.0
 */
public class DateUtils extends PropertyEditorSupport {

    /**
     * 开始日期的前缀
     */
    public static String dateStr = "%s%s%s%-%s%%s%-01 00:00:00";

    /**
     * 结束日期的前缀
     */
    public static String dateEnd = "%s%s%s%-%s%%s%-31 23:59:59";

    /**
     * yyyy-MM-dd
     */
    public static final SimpleDateFormat date_sdf = new SimpleDateFormat("yyyy-MM-dd");

    /**
     * yyyy-MM
     */
    public static final SimpleDateFormat date_month_sdf = new SimpleDateFormat("yyyy-MM");


    /**
     * 每月的开始时间
     */
    public static final SimpleDateFormat str_date_sdf = new SimpleDateFormat("yyyy-MM-01 00:00:00");

    /**
     * 每月的结束时间
     */
    public static final SimpleDateFormat end_date_sdf = new SimpleDateFormat("yyyy-MM-31 23:59:59");

    /**
     * yyyyMMdd
     */
    public static final SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
    // 各种时间格式
    /**
     * yyyy年MM月dd日
     */
    public static final SimpleDateFormat date_sdf_wz = new SimpleDateFormat("yyyy年MM月dd日");
    /**
     * yyyy-MM-dd HH:mm
     */
    public static final SimpleDateFormat time_sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    /**
     * yyyyMMddHHmmss
     */
    public static final SimpleDateFormat yyyymmddhhmmss = new SimpleDateFormat("yyyyMMddHHmmss");
    /**
     * HH:mm
     */
    public static final SimpleDateFormat short_time_sdf = new SimpleDateFormat("HH:mm");
    /**
     * yyyy-MM-dd HH:mm:ss
     */
    public static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * MM
     */
    public static final SimpleDateFormat month_sdf = new SimpleDateFormat("MM");

    // 以毫秒表示的时间
    private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
    private static final long HOUR_IN_MILLIS = 3600 * 1000;
    private static final long MINUTE_IN_MILLIS = 60 * 1000;
    private static final long SECOND_IN_MILLIS = 1000;

    // 指定模式的时间格式
    private static SimpleDateFormat getSDFormat(String pattern) {
        return new SimpleDateFormat(pattern);
    }

    /**
     * 当前日历，这里用中国时间表示
     *
     * @return 以当地时区表示的系统当前日历
     */
    public static Calendar getCalendar() {
        return Calendar.getInstance();
    }

    /**
     * 指定毫秒数表示的日历
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日历
     */
    public static Calendar getCalendar(long millis) {
        Calendar cal = Calendar.getInstance();
        // --------------------cal.setTimeInMillis(millis);
        cal.setTime(new Date(millis));
        return cal;
    }

    // ////////////////////////////////////////////////////////////////////////////
    // getDate
    // 各种方式获取的Date
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 当前日期
     *
     * @return 系统当前时间
     */
    public static Date getDate() {
        return new Date();
    }

    /**
     * 指定毫秒数表示的日期
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日期
     */
    public static Date getDate(long millis) {
        return new Date(millis);
    }

    /**
     * 时间戳转换为字符串
     *
     * @param time
     * @return
     */
    public static String timestamptoStr(Timestamp time) {
        Date date = null;
        if (null != time) {
            date = new Date(time.getTime());
        }
        return date2Str(date_sdf);
    }

    /**
     * 字符串转换时间戳
     *
     * @param str
     * @return
     */
    public static Timestamp str2Timestamp(String str) {
        Date date = str2Date(str, date_sdf);
        return new Timestamp(date.getTime());
    }

    /**
     * 字符串转换成日期
     *
     * @param str
     * @param sdf
     * @return
     */
    public static Date str2Date(String str, SimpleDateFormat sdf) {
        if (null == str || "".equals(str)) {
            return null;
        }
        Date date = null;
        try {
            date = sdf.parse(str);
            return date;
        } catch (ParseException e) {
            System.out.println("str = " + str);
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 日期转换为字符串
     *
     * @return 字符串
     */
    public static String date2Str(SimpleDateFormat date_sdf) {
        Date date = getDate();
        if (null == date) {
            return null;
        }
        return date_sdf.format(date);
    }

    /**
     * 格式化时间
     *
     * @param date
     * @param format
     * @return
     */
    public static String dateformat(String date, String format) {
        SimpleDateFormat sformat = new SimpleDateFormat(format);
        Date _date = null;
        try {
            _date = sformat.parse(date);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return sformat.format(_date);
    }

    /**
     * 日期转换为字符串
     *
     * @param date 日期
     * @return 字符串
     */
    public static String date2Str(Date date, SimpleDateFormat date_sdf) {
        if (null == date) {
            return null;
        }
        return date_sdf.format(date);
    }

    /**
     * 日期转换为字符串 yyyy-MM-dd HH:mm:ss
     *
     * @param date 日期
     * @return 字符串
     */
    public static String date2Str(Date date) {
        if (null == date) {
            return null;
        }
        return datetimeFormat.format(date);
    }


    /**
     * 日期转换为字符串
     *
     * @param format 日期格式
     * @return 字符串
     */
    public static String getDate(String format) {
        Date date = new Date();
        if (null == date) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 获取当前时间 字符串类型
     *
     * @return yyyy-MM-dd HH:mm:ss 字符串
     */
    public static String date2Str() {
        Date date = new Date();
        if (null == date) {
            return null;
        }
        return datetimeFormat.format(date);
    }


    /**
     * 指定毫秒数的时间戳
     *
     * @param millis 毫秒数
     * @return 指定毫秒数的时间戳
     */
    public static Timestamp getTimestamp(long millis) {
        return new Timestamp(millis);
    }

    /**
     * 以字符形式表示的时间戳
     *
     * @param time 毫秒数
     * @return 以字符形式表示的时间戳
     */
    public static Timestamp getTimestamp(String time) {
        return new Timestamp(Long.parseLong(time));
    }

    /**
     * 系统当前的时间戳
     *
     * @return 系统当前的时间戳
     */
    public static Timestamp getTimestamp() {
        return new Timestamp(System.currentTimeMillis());
    }

    /**
     * 当前时间，格式 yyyy-MM-dd HH:mm:ss
     *
     * @return 当前时间的标准形式字符串
     */
    public static String now() {
        return datetimeFormat.format(getCalendar().getTime());
    }

    /**
     * 指定日期的时间戳
     *
     * @param date 指定日期
     * @return 指定日期的时间戳
     */
    public static Timestamp getTimestamp(Date date) {
        return new Timestamp(date.getTime());
    }

    /**
     * 指定日历的时间戳
     *
     * @param cal 指定日历
     * @return 指定日历的时间戳
     */
    public static Timestamp getCalendarTimestamp(Calendar cal) {
        // ---------------------return new Timestamp(cal.getTimeInMillis());
        return new Timestamp(cal.getTime().getTime());
    }

    public static Timestamp gettimestamp() {
        Date dt = new Date();
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = df.format(dt);
        Timestamp buydate = Timestamp.valueOf(nowTime);
        return buydate;
    }

    // ////////////////////////////////////////////////////////////////////////////
    // getMillis
    // 各种方式获取的Millis
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 系统时间的毫秒数
     *
     * @return 系统时间的毫秒数
     */
    public static long getMillis() {
        return System.currentTimeMillis();
    }

    /**
     * 指定日历的毫秒数
     *
     * @param cal 指定日历
     * @return 指定日历的毫秒数
     */
    public static long getMillis(Calendar cal) {
        // --------------------return cal.getTimeInMillis();
        return cal.getTime().getTime();
    }

    /**
     * 指定日期的毫秒数
     *
     * @param date 指定日期
     * @return 指定日期的毫秒数
     */
    public static long getMillis(Date date) {
        return date.getTime();
    }

    /**
     * 指定时间戳的毫秒数
     *
     * @param ts 指定时间戳
     * @return 指定时间戳的毫秒数
     */
    public static long getMillis(Timestamp ts) {
        return ts.getTime();
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatDate
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：年-月-日
     *
     * @return 默认日期按“年-月-日“格式显示
     */
    public static String formatDate() {
        return date_sdf.format(getCalendar().getTime());
    }

    /**
     * 默认方式表示的系统当前日期，具体格式：yyyy-MM-dd HH:mm:ss
     *
     * @return 默认日期按“yyyy-MM-dd HH:mm:ss“格式显示
     */
    public static String formatDateTime() {
        return datetimeFormat.format(getCalendar().getTime());
    }

    /**
     * 获取时间字符串
     */
    public static String getDataString(SimpleDateFormat formatstr) {
        return formatstr.format(getCalendar().getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日
     *
     * @param cal 指定的日期
     * @return 指定日期按“年-月-日“格式显示
     */
    public static String formatDate(Calendar cal) {
        return date_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日
     *
     * @param date 指定的日期
     * @return 指定日期按“年-月-日“格式显示
     */
    public static String formatDate(Date date) {
        return date_sdf.format(date);
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日“格式显示
     */
    public static String formatDate(long millis) {
        return date_sdf.format(new Date(millis));
    }

    /**
     * 默认日期按指定格式显示
     *
     * @param pattern 指定的格式
     * @return 默认日期按指定格式显示
     */
    public static String formatDate(String pattern) {
        return getSDFormat(pattern).format(getCalendar().getTime());
    }

    /**
     * 指定日期按指定格式显示
     *
     * @param cal     指定的日期
     * @param pattern 指定的格式
     * @return 指定日期按指定格式显示
     */
    public static String formatDate(Calendar cal, String pattern) {
        return getSDFormat(pattern).format(cal.getTime());
    }

    /**
     * 指定日期按指定格式显示
     *
     * @param date    指定的日期
     * @param pattern 指定的格式
     * @return 指定日期按指定格式显示
     */
    public static String formatDate(Date date, String pattern) {
        return getSDFormat(pattern).format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatTime
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：年-月-日 时：分
     *
     * @return 默认日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime() {
        return time_sdf.format(getCalendar().getTime());
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(long millis) {
        return time_sdf.format(new Date(millis));
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param cal 指定的日期
     * @return 指定日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(Calendar cal) {
        return time_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param date 指定的日期
     * @return 指定日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(Date date) {
        return time_sdf.format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatShortTime
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：时：分
     *
     * @return 默认日期按“时：分“格式显示
     */
    public static String formatShortTime() {
        return short_time_sdf.format(getCalendar().getTime());
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：时：分
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“时：分“格式显示
     */
    public static String formatShortTime(long millis) {
        return short_time_sdf.format(new Date(millis));
    }

    /**
     * 指定日期的默认显示，具体格式：时：分
     *
     * @param cal 指定的日期
     * @return 指定日期按“时：分“格式显示
     */
    public static String formatShortTime(Calendar cal) {
        return short_time_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：时：分
     *
     * @param date 指定的日期
     * @return 指定日期按“时：分“格式显示
     */
    public static String formatShortTime(Date date) {
        return short_time_sdf.format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // parseDate
    // parseCalendar
    // parseTimestamp
    // 将字符串按照一定的格式转化为日期或时间
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     */
    public static Date parseDate(String src, String pattern) throws ParseException {
        return getSDFormat(pattern).parse(src);

    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     */
    public static Calendar parseCalendar(String src, String pattern) throws ParseException {

        Date date = parseDate(src, pattern);
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal;
    }

    public static String formatAddDate(String src, String pattern, int amount) throws ParseException {
        Calendar cal;
        cal = parseCalendar(src, pattern);
        cal.add(Calendar.DATE, amount);
        return formatDate(cal);
    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的时间戳
     * @throws ParseException
     */
    public static Timestamp parseTimestamp(String src, String pattern) throws ParseException {
        Date date = parseDate(src, pattern);
        return new Timestamp(date.getTime());
    }

    // ////////////////////////////////////////////////////////////////////////////
    // dateDiff
    // 计算两个日期之间的差值
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 计算两个时间之间的差值，根据标志的不同而不同
     *
     * @param flag   计算标志，表示按照年/月/日/时/分/秒等计算
     * @param calSrc 减数
     * @param calDes 被减数
     * @return 两个日期之间的差值
     */
    public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {

        long millisDiff = getMillis(calSrc) - getMillis(calDes);

        if (flag == 'y') {
            return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
        }

        if (flag == 'd') {
            return (int) (millisDiff / DAY_IN_MILLIS);
        }

        if (flag == 'h') {
            return (int) (millisDiff / HOUR_IN_MILLIS);
        }

        if (flag == 'm') {
            return (int) (millisDiff / MINUTE_IN_MILLIS);
        }

        if (flag == 's') {
            return (int) (millisDiff / SECOND_IN_MILLIS);
        }

        return 0;
    }


    /**
     * 两个时间相差的天数
     *
     * @author jesse
     * @since austin年10月16日 下午4:42:34
     */
    public static int compareDays(Date date1, Date date2) {
        Calendar calendar1 = Calendar.getInstance();
        Calendar calendar2 = Calendar.getInstance();
        calendar1.setTime(date1);
        calendar2.setTime(date2);
        int day1 = calendar1.get(Calendar.DAY_OF_YEAR);
        int day2 = calendar2.get(Calendar.DAY_OF_YEAR);
        int year1 = calendar1.get(Calendar.YEAR);
        int year2 = calendar2.get(Calendar.YEAR);
        if (year1 > year2) {
            int tempyear = year1;
            int tempday = day1;
            day1 = day2;
            day2 = tempday;
            year1 = year2;
            year2 = tempyear;
        }
        if (year1 == year2) {
            //System.out.println("相隔的天数为 = " + (day2 - day1)  + "天");

            return day2 - day1;
        } else {
            int DayCount = 0;
            for (int i = year1; i < year2; i++) {
                if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {
                    DayCount += 366;
                } else {
                    DayCount += 365;
                }
            }
            //System.out.println("相隔的天数为  " + DayCount+(day2-day1)  + "天");
            return DayCount + (day2 - day1);

        }
    }


    /**
     * String类型 转换为Date, 如果参数长度为10 转换格式”yyyy-MM-dd“ 如果参数长度为19 转换格式”yyyy-MM-dd
     * HH:mm:ss“ * @param text String类型的时间值
     */
    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        if (StringUtils.hasText(text)) {
            try {
                if (text.indexOf(":") == -1 && text.length() == 10) {
                    setValue(this.date_sdf.parse(text));
                } else if (text.indexOf(":") > 0 && text.length() == 19) {
                    setValue(this.datetimeFormat.parse(text));
                } else {
                    throw new IllegalArgumentException("Could not parse date, date format is error ");
                }
            } catch (ParseException ex) {
                IllegalArgumentException iae = new IllegalArgumentException("Could not parse date: " + ex.getMessage());
                iae.initCause(ex);
                throw iae;
            }
        } else {
            setValue(null);
        }
    }

    public static int getYear() {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(getDate());
        return calendar.get(Calendar.YEAR);
    }

    /**
     * 获取三个月以前的开始时间
     *
     * @author jesse
     * @since austin年10月8日 上午9:43:48
     */
    public static String getThreeMonthsStrTime() {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -3);  //设置为前3月
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 根据传入时间返回3个月以后的时间
     *
     * @author jesse
     * @since austin年10月8日 上午9:43:48
     */
    public static String getThreeMonthsAfter(String time) {

        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(str2Date(time, datetimeFormat));//把当前时间赋给日历
        calendar.add(Calendar.MONTH, +3);  //设置为前多少个月
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取本月的开始时间
     *
     * @return
     */
    public static String getStartTimeOfMonth() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(getDate());
        // 设置为1号,当前日期既为本月第一天
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取上月的开始时间
     *
     * @return
     */
    public static String getStartTimeOfLastMonth() {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -1);  //设置为前多少个月
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);

        return date2Str(calendar.getTime(), datetimeFormat);
    }

    /**
     * 获取上月的开始时间
     *
     * @param time 传入的月份时间信息
     * @return 上月的时间
     */
    public static String getStartTimeOfLastMonth(String time) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(str2Date(time, str_date_sdf));//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -1);  //设置为前多少个月
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);

        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取本月结束时间，无参数
     *
     * @return
     */
    public static String getEndTimeOfThisMonth() {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        return date2Str(calendar.getTime(), end_date_sdf);
    }

    /**
     * 获取指定月份的结束时间，带参数
     *
     * @author jesse
     * @since 2021年2月24日 下午3:45:15
     */
    public static String getEndTimeOfThisMonth(String time) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(str2Date(time, str_date_sdf));//把当前时间赋给日历
        return date2Str(calendar.getTime(), end_date_sdf);
    }


    /**
     * 获取上月结束时间
     *
     * @return
     */
    public static String getEndTimeOfLastMonth() {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -1);  //设置为前多少个月

        return date2Str(calendar.getTime(), end_date_sdf);
    }


    /**
     * 获取今天的开始时间
     *
     * @return
     */
    public static String getStartTimeThisDay() {
        Calendar dateStart = Calendar.getInstance();
        dateStart.setTime(getDate());
        dateStart.set(Calendar.HOUR_OF_DAY, 0);
        dateStart.set(Calendar.MINUTE, 0);
        dateStart.set(Calendar.SECOND, 0);
        return date2Str(dateStart.getTime(), datetimeFormat);
    }


    /**
     * 获取多少天之前的时间
     *
     * @author jesse
     * @since austin年11月25日 上午10:27:39
     */
    public static String getAgoDays(int day) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.DATE, -day);  //设置为前多少天
        return date2Str(calendar.getTime(), datetimeFormat);
    }

    /**
     * 获取多少天之前的开始时间
     *
     * @author jesse
     * @since austin年11月25日 上午10:27:39
     */
    public static String getAgoDaysStrTime(int day) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.DATE, -day);  //设置为前多少天
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取多少个月以前的当前时间
     *
     * @author jesse
     * @since austin年10月8日 上午9:43:48
     */
    public static String getAgoMonth(int month) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -month);  //设置为前多少个月
        return date2Str(calendar.getTime(), datetimeFormat);
    }

    /**
     * 获取多少个月以前的当天开始时间
     *
     * @author jesse
     * @since austin年10月8日 上午9:43:48
     */
    public static String getAgoMonthStr(int month) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        //calendar.set(Calendar.MONTH, 1, 0, 0, 0);//设置当月的起始时间
        //calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -month);  //设置为多少年前
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取多少年以前的今天时间
     *
     * @author jesse
     * @since austin年10月8日 上午9:43:48
     */
    public static String getAgoYears(int year) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.YEAR, -year);  //设置为多少年前

        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取多少年以前的当月开始时间
     *
     * @author jesse
     * @since austin年10月8日 上午9:43:48
     */
    public static String getAgoYearsStr(int year) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.set(calendar.get(Calendar.YEAR),
                calendar.get(Calendar.MONTH), 1, 0, 0, 0);//设置当月的起始时间
        //calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.YEAR, -year);  //设置为多少年前
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 时间戳转换成 date
     *
     * @param longDate 将要转换的原始时间戳
     * @throws ParseException
     */
    public static Date parseDate(long longDate) {
        try {

            String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(longDate * 1000));
            return str2Date(date, datetimeFormat);

        } catch (Exception e) {

            e.printStackTrace();
        }
        return null;

    }

    /**
     * 获取十二个月前的所有月份
     *
     * @author jesse
     * @since austin年12月9日 下午6:56:51
     */
    public static List<Map<String, String>> getAllMonthOfYear(String strTime) {
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        try {
            Map<String, String> map = null;

            //SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
            // String nowdate=format.format(new Date());//当前月份

            Date d1 = new SimpleDateFormat("yyyy-MM").parse(strTime);//定义起始日期

            Date d2 = new SimpleDateFormat("yyyy-MM").parse(getAgoMonth(-1));//定义结束日期  可以去当前月也可以手动写日期。

            Calendar dd = Calendar.getInstance();//定义日期实例

            dd.setTime(d1);//设置日期起始时间

            while (dd.getTime().before(d2)) {//判断是否到结束日期

                map = new HashMap<String, String>();

                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
                String str = sdf.format(dd.getTime());
                map.put("str", str + "-01 00:00:00");
                map.put("end", str + "-31 23:59:59");
                //System.out.println(str);//输出日期结果

                dd.add(Calendar.MONTH, 1);//进行当前日期月份加1
                list.add(map);
            }

        } catch (Exception e) {

        }

        return list;
    }

    /**
     * 获取多少个月之前的时间
     *
     * @param time     传入的月份时间信息
     * @param agoMonth 多少个月之前
     * @return 上月的时间
     */
    public static String getAgoTime(Date time, int agoMonth) {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(time);//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -agoMonth);  //设置为前多少个月

        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 获取最近几个月（返回多个月份）
     *
     * @author jesse
     * @since 2021年5月6日 下午3:50:27
     */
    public static List<String> getAgoMonthList(int counts) {

        List<String> list = new ArrayList<String>();
        if (counts == 0 || counts == 1)//0,1 直接获取本月
        {
            list.add(getStartTimeOfMonth());
        } else {
            for (int i = 0; i < counts; i++) {
                Calendar calendar = Calendar.getInstance(); //得到日历
                calendar.setTime(gettimestamp());//把当前时间赋给日历
                calendar.add(Calendar.MONTH, -i);  //设置为多少月前
                calendar.set(Calendar.DAY_OF_MONTH, 1);
                calendar.set(Calendar.HOUR_OF_DAY, 0);
                calendar.set(Calendar.MINUTE, 0);
                calendar.set(Calendar.SECOND, 0);
                date2Str(calendar.getTime(), datetimeFormat);
                list.add(date2Str(calendar.getTime(), datetimeFormat));
            }
        }
        return list;
    }


    public static List<String> getMonthFullDay(int year, int month) {
        SimpleDateFormat dateFormatYYYYMMDD = new SimpleDateFormat("yyyy-MM-dd");
        List<String> fullDayList = new ArrayList<>(32);
        // 获得当前日期对象
        Calendar cal = Calendar.getInstance();
        cal.clear();// 清除信息
        cal.set(Calendar.YEAR, year);
        // 1月从0开始
        cal.set(Calendar.MONTH, month - 1);
        // 当月1号
        cal.set(Calendar.DAY_OF_MONTH, 1);
        int count = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        for (int j = 1; j <= count; j++) {
            fullDayList.add(dateFormatYYYYMMDD.format(cal.getTime()));
            cal.add(Calendar.DAY_OF_MONTH, 1);
        }
        return fullDayList;
    }


    /**
     * 获取某个月份天数
     *
     * @param date
     * @return
     */
    public static int getDaysOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }

    /**
     * 传入年月字符串获取月的所有的天
     *
     * @param dateStr 2021-05
     * @return
     */
    public static List<String> getDayListOfMonth(String dateStr) throws ParseException {
        int year = Integer.parseInt(dateStr.substring(0, 4));
        int month = Integer.parseInt(dateStr.substring(5, 7));
        return getMonthFullDay(year, month);
    }

    /**
     * 根据传入的月份获取上个月的开始时间
     *
     * @param month 2021-05
     * @return
     * @author austin
     */
    public static String getStartTimeOfLastMonthBySelectMonth(String month) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Date date = sdf.parse(month);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, -1);  //设置为前多少个月
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);

        return date2Str(calendar.getTime(), datetimeFormat);
    }

    /**
     * 截取传入的时间字符串为年月格式：2021-06
     * @author austin
     * @param time
     * @return
     */
    /**
     * 时间转成文字时间段
     *
     * @author jesse
     * @since 2021年7月2日 下午4:13:30
     */
    public static String convertTimeToCharacters(Date agoDate) {
        String characters = "";
        Date thisDate = new Date();
        int day = compareDays(agoDate, thisDate);
        if (day <= 30) {
            characters = "1个月内";
        } else if (day > 30 && day <= 90) {
            characters = "3个月内";
        } else if (day > 90 && day <= 180) {
            characters = "半年内";
        } else if (day > 180 && day <= 365) {
            characters = "1年内";
        } else if (day > 365 && day <= 545) {
            characters = "1年半内";
        } else if (day > 545 && day <= 730) {
            characters = "2年内";
        } else {
            characters = "2年以上";
        }
        return characters;
    }

    /**
     * 截取传入的时间字符串为年月格式：2021-06
     *
     * @param time
     * @return
     * @author austin
     */
    public static String getSubDateStrOfTime(String time) {
        return time.substring(0, 7);
    }

    /**
     * 获取半年前的开始时间
     *
     * @return 2021年07月03日
     * @author austin
     */
    public static String getHalfYearAgoStrTime() {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -6);  //设置为前6月
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }

    /**
     * 获取一年前的开始时间
     *
     * @return 2021年07月03日
     * @author austin
     */
    public static String getOneYearAgoStrTime() {
        Calendar calendar = Calendar.getInstance(); //得到日历
        calendar.setTime(gettimestamp());//把当前时间赋给日历
        calendar.add(Calendar.MONTH, -12);  //设置为前12月
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return date2Str(calendar.getTime(), datetimeFormat);
    }


    /**
     * 日期转换为字符串 yyyyMMdd 只返回年月日格式
     *
     * @param date
     * @return 字符串
     */
    public static String date2StrFormat(Date date) {
        if (null == date) {
            return null;
        }
        return yyyyMMdd.format(date);
    }

    /**
     * 获取12个月数据[01,02,03..11,12]
     *
     * @return list
     */
    public static List<String> get12Months() {
        List<String> list = new ArrayList<>();
        for (int i = 1; i <= 12; i++) {
            if (i < 10) {
                list.add("0" + i);
            } else {
                list.add(String.valueOf(i));
            }
        }
        return list;
    }

    /**
     * 获取两个时间之间的所有日期
     *
     * @author austin
     * @since 2021年08月05日 上午12:30
     */
    public static List<String> getDays(String startTime, String endTime) {
        // 返回的日期集合
        List<String> days = new ArrayList<String>();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date start = dateFormat.parse(startTime);
            Date end = dateFormat.parse(endTime);
            Calendar tempStart = Calendar.getInstance();
            tempStart.setTime(start);

            Calendar tempEnd = Calendar.getInstance();
            tempEnd.setTime(end);
            tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)

            while (tempStart.before(tempEnd)) {
                days.add(dateFormat.format(tempStart.getTime()));
                tempStart.add(Calendar.DAY_OF_YEAR, 1);
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }

        return days;
    }

    /**
     * 获取当前时间所在周的周一和周日的日期时间
     *
     * @author austin
     * @since 2021年08月05日 下午17:13
     */
    public static Map<String, String> getWeekDate() {
        Map<String, String> map = new HashMap();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        Calendar cal = Calendar.getInstance();
        // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
        cal.setFirstDayOfWeek(Calendar.MONDAY);
        // 获得当前日期是一个星期的第几天
        int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
        if (dayWeek == 1) {
            dayWeek = 8;
        }

        cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - dayWeek);// 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
        Date mondayDate = cal.getTime();
        String weekBegin = sdf.format(mondayDate);

        cal.add(Calendar.DATE, 4 + cal.getFirstDayOfWeek());
        Date sundayDate = cal.getTime();
        String weekEnd = sdf.format(sundayDate);

        map.put("mondayDate", weekBegin);
        map.put("sundayDate", weekEnd);
        return map;
    }

    public static void main(String[] args) throws ParseException {
        Map<String, String> map = DateUtils.getWeekDate();
        System.out.println(DateUtils.getDays(map.get("mondayDate"), map.get("sundayDate")));

    }
}
